package com.wl.common.system.service.impl;//package com.wl.common.system.service.impl;
//
//import cn.hutool.core.collection.CollUtil;
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
//import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
//import com.google.common.collect.Lists;
//import com.wl.common.core.constant.ConstantSystem;
//import com.wl.common.core.utils.tree.TreeUtils;
//import com.wl.common.mybatis.model.AbstractBaseModel;
//import com.wl.common.mybatis.utils.PageUtils;
//import com.wl.common.system.dao.SysMenuMapper;
//import com.wl.common.system.dao.SysRoleMapper;
//import com.wl.common.system.dao.SysRoleMenuMapper;
//import com.wl.common.system.dao.SysUserMapper;
//import com.wl.common.system.domain.SysMenu;
//import com.wl.common.system.domain.SysRoleMenu;
//import com.wl.common.system.service.SysMenuService;
//import com.wl.common.system.service.SysRoleMenuService;
//import com.wl.common.system.support.dto.SysMenuDTO;
//import com.wl.common.system.support.dto.SysMenuDistributeDTO;
//import com.wl.common.system.support.dto.query.SysMenuQueryDTO;
//import com.wl.common.system.support.enums.RoleTypeEnum;
//import com.wl.common.system.support.vo.MetaVO;
//import com.wl.common.system.support.vo.RouterVO;
//import com.wl.common.system.support.vo.SysMenuVO;
//import com.wl.common.system.support.vo.SysUserVO;
//import com.wl.system.api.domain.SysRole;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.BeanUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.domain.Sort;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.util.Assert;
//
//import java.util.*;
//import java.util.stream.Collectors;
//
///**
// * 菜单表 服务实现类
// *
// * @author wanglin
// * @since 2023-09-18
// */
//@Service
//public class SysMenuServiceImpl implements SysMenuService {
//
//    @Autowired
//    private SysMenuMapper sysMenuMapper;
//    @Autowired
//    private SysUserMapper userMapper;
//    @Autowired
//    private SysRoleMapper roleMapper;
//    @Autowired
//    private SysRoleMenuMapper roleMenuMapper;
//    @Autowired
//    private SysRoleMenuService roleMenuService;
//    @Autowired
////    private DynamicSecurityMetadataSource dynamicSecurityMetadataSource;
//
////    @Transactional(readOnly = true)
////    @Override
////    public DataStoreDTO<SysMenuVO> page(Pageable pageable, SysMenuQueryDTO queryDto) {
////        QueryWrapper<SysMenu> queryWrapper = this.buildQuery(queryDto);
////        Page<SysMenu> page = PageUtils.transferPage(pageable);
////        Page<SysMenu> result = this.sysMenuMapper.selectPage(page, queryWrapper);
////        return new DataStoreDTO(result.getTotal(), this.transferVo(result.getRecords()));
////    }
//
////    @Transactional(readOnly = true)
////    @Override
////    public List<SysMenuVO> list(Sort sort, SysMenuQueryDTO queryDto) {
////        QueryWrapper<SysMenu> queryWrapper = this.buildQuery(queryDto);
////        PageUtils.transferSort(queryWrapper, sort);
////        return this.transferVo(this.sysMenuMapper.selectList(queryWrapper));
////    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void save(SysMenuDTO dto) {
//        //菜单级数不能超过2级
////        Assert.isTrue(dto.getLevel() <= ConstantSystem.INTEGER_TWO, "菜单级数不能超过2级");
//        //若选择：无上级菜单，则要设为null
////        if (dto.getParentId().equals(Constants.MENU_PARENT_ID)) {
////            dto.setParentId(null);
////        }
//        //1- 参数验证,若为菜单级数为一级，则父级菜单必须为空
////        if (NumberUtils.INTEGER_ONE.equals(dto.getLevel())) {
////            Assert.isTrue(StringUtils.isBlank(dto.getParentId()), "菜单级数和父级菜单不匹配，注意：一级菜单没有父级菜单！！！");
////        }
//
////        if (ConstantSystem.TYPE_MENU.equals(dto.getType())) {
////            cn.hutool.core.lang.Assert.notBlank(dto.getComponent(), "组件路径不能为空");
////        }
//        //验证上级菜单是否存在
//        if (StringUtils.isNotBlank(dto.getParentId())) {
//            SysMenu entity = sysMenuMapper.selectById(dto.getParentId());
//            Assert.notNull(entity, "上级菜单不存在");
//        }
//        //2- 唯一性验证
////        Assert.isNull(validateExists(dto.getName(), dto.getLevel()), "同级菜单已存在");
//        //菜单名称和type不能同时重复
//        List<SysMenu> menuList = sysMenuMapper.selectList(new LambdaQueryWrapper<SysMenu>().eq(SysMenu::getName, dto.getName()).eq(SysMenu::getType, dto.getType()));
//        cn.hutool.core.lang.Assert.isTrue(CollUtil.isEmpty(menuList), "同一类型菜单名称不能重复");
//        dto.setId(null);
//        sysMenuMapper.insert(this.transferEntity(null, dto));
//    }
//
////    @Transactional(rollbackFor = Exception.class)
////    @Override
////    public void save(SysMenuDTO dto) {
////        //菜单级数不能超过2级
////        Assert.isTrue(dto.getLevel() <= ConstantSystem.INTEGER_TWO, "菜单级数不能超过2级");
////        //若选择：无上级菜单，则要设为null
//////        if (dto.getParentId().equals(Constants.MENU_PARENT_ID)) {
//////            dto.setParentId(null);
//////        }
////        //1- 参数验证,若为菜单级数为一级，则父级菜单必须为空
////        if (NumberUtils.INTEGER_ONE.equals(dto.getLevel())) {
////            Assert.isTrue(StringUtils.isBlank(dto.getParentId()), "菜单级数和父级菜单不匹配，注意：一级菜单没有父级菜单！！！");
////        }
////        //验证上级菜单是否存在
////        if (StringUtils.isNotBlank(dto.getParentId())) {
////            SysMenu entity = sysMenuMapper.selectById(dto.getParentId());
////            Assert.notNull(entity, "上级菜单不存在");
////            Assert.isTrue(entity.getLevel() < dto.getLevel(), "菜单级数不能大于父级菜单级数");
////        }
////        //2- 唯一性验证
////        Assert.isNull(validateExists(dto.getName(), dto.getLevel()), "同级菜单已存在");
////        dto.setId(null);
////        //设置默认图标
////        if (NumberUtils.INTEGER_ONE.equals(dto.getLevel())) {
////            dto.setIcon(ConstantSystem.MENU_ICON);
////        } else {
////            dto.setIcon(ConstantSystem.MENU_LIST_ICON);
////        }
////        sysMenuMapper.insert(this.transferEntity(null, dto));
////        //修改了配置，需要重新加载资源数据
//////        dynamicSecurityMetadataSource.clearDataSource();
//////        dto.setId(null);
//////        sysMenuMapper.insert(this.transferEntity(null, dto));
////    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void update(SysMenuDTO dto) {
//        Assert.hasText(dto.getId(), "id不能为空");
//        //若选择：无上级菜单，则要设为null
////        if (dto.getParentId().equals(Constants.MENU_PARENT_ID)) {
////            dto.setParentId(null);
////        }
//        //验证上级菜单是否存在
////        if (StringUtils.isNotBlank(dto.getParentId())) {
////            SysMenu entity = sysMenuMapper.selectById(dto.getParentId());
////            Assert.notNull(entity, "上级菜单不存在");
////            Assert.isTrue(entity.getLevel() < dto.getLevel(), "菜单级数不能大于父级菜单级数");
////        }
//
////        if (ConstantSystem.TYPE_MENU.equals(dto.getType())) {
////            cn.hutool.core.lang.Assert.notBlank(dto.getComponent(), "组件路径不能为空");
////        }
//        //存在性验证
//        SysMenu entity = sysMenuMapper.selectById(dto.getId());
//        Assert.notNull(entity, "找不到id为： " + dto.getId() + " 的记录");
//        //2- 唯一性验证
////        SysMenu sysMenu = validateExists(dto.getName(), dto.getLevel());
////        if (Objects.nonNull(sysMenu)) {
////            Assert.isTrue(sysMenu.getId().equals(dto.getId()), "同级菜单已存在");
////        }
//        //验证上级菜单是否存在
//        if (StringUtils.isNotBlank(dto.getParentId())) {
//            Assert.notNull(sysMenuMapper.selectById(dto.getParentId()), "上级菜单不存在");
//        }
//        List<SysMenu> menuList = sysMenuMapper.selectList(new LambdaQueryWrapper<SysMenu>().eq(SysMenu::getName, dto.getName()).eq(SysMenu::getType, dto.getType()));
//        if (CollUtil.isNotEmpty(menuList)) {
//            Assert.isTrue(dto.getId().equals(menuList.get(0).getId()), "同一类型菜单名称不能重复");
//        }
//        sysMenuMapper.updateById(this.transferEntity(entity, dto));
//        //修改了配置，需要重新加载资源数据
////        dynamicSecurityMetadataSource.clearDataSource();
//    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void delete(Set<String> ids) {
//        if (CollectionUtils.isEmpty(ids)) {
//            return;
//        }
//
//        //验证删除的菜单是否绑定角色
//        List<SysRoleMenu> roleMenuList = roleMenuMapper.selectList(new LambdaQueryWrapper<SysRoleMenu>().in(SysRoleMenu::getMenuId, ids));
//        Assert.isTrue(CollUtil.isEmpty(roleMenuList), "删除的菜单已绑定角色，请先删除绑定关系！");
//
//        List<String> deleteIdList = Lists.newArrayList();
//        //1-删除与该菜单有关的子、父菜单
//        List<SysMenu> allMenuList = sysMenuMapper.selectList(null);
//        if (CollectionUtils.isNotEmpty(allMenuList)) {
//            List<SysMenu> parentList = allMenuList.stream().filter(e -> ids.contains(e.getParentId())).collect(Collectors.toList());
//            if (CollectionUtils.isNotEmpty(parentList)) {
//                //删除所有父菜单
//                List<String> deleteParentIdList = parentList.stream().map(e -> e.getId()).collect(Collectors.toList());
//                deleteIdList.addAll(deleteParentIdList);
//                //删除子菜单
//                deleteIdList.addAll(ids.stream().filter(e -> !deleteParentIdList.contains(e)).collect(Collectors.toList()));
//            } else {
//                //说明删除的全是子菜单
//                deleteIdList.addAll(ids);
//            }
//        }
//        sysMenuMapper.deleteBatchIds(deleteIdList);
//
//        //2-删除角色对应的菜单
//        //获取所有的roleMenu数据
////        List<SysRoleMenu> allRoleMenuList = roleMenuMapper.selectList(null);
////        if (CollectionUtils.isNotEmpty(allRoleMenuList)) {
////            roleMenuMapper.delete(new LambdaQueryWrapper<SysRoleMenu>().in(SysRoleMenu::getMenuId, deleteIdList));
////        }
//
//        //修改了配置，需要重新加载资源数据
////            dynamicSecurityMetadataSource.clearDataSource();
//    }
//
//    @Transactional(readOnly = true)
//    @Override
//    public SysMenuVO get(String id) {
//        Assert.hasText(id, "id不能为空");
//        SysMenu entity = sysMenuMapper.selectById(id);
//        Assert.notNull(entity, "找不到id为 " + id + " 的记录");
//        return this.transferVo(entity, getMenuNameMap());
//    }
//
//    @Transactional(readOnly = true)
//    @Override
//    public List<SysMenuVO> treeMenuList(Sort sort, SysMenuQueryDTO queryDto) {
//        //条件查询
//        List<SysMenuVO> menuList = list(sort, queryDto);
//        if (CollectionUtils.isEmpty(menuList)) {
//            return Lists.newArrayList();
//        }
//        //查询全部
//        List<SysMenuVO> allMenuList = list(sort, null);
//        //若有上级菜单，则添加上级菜单
//        //过滤父级菜单
//        List<String> parentIdList = menuList.stream().filter(e -> StringUtils.isNotBlank(e.getParentId())).map(e -> e.getParentId()).distinct().collect(Collectors.toList());
//        List<SysMenuVO> parentVoList = allMenuList.stream().filter(e -> parentIdList.contains(e.getId())).collect(Collectors.toList());
//        //排除上级菜单已存在的情况
//        List<SysMenuVO> voList = parentVoList.stream().filter(e -> !menuList.contains(e)).collect(Collectors.toList());
//        //添加上级菜单
//        menuList.addAll(voList);
//        return TreeUtils.generateTrees(menuList.stream().sorted(Comparator.comparing(SysMenuVO::getOrderIndex)).collect(Collectors.toList()));
//    }
//
//    @Transactional(readOnly = true)
//    @Override
//    public List<SysMenuVO> treeMenuListByRoleId(String roleId) {
//        //验证角色id是否存在
//        SysRole roleEntity = roleMapper.selectById(roleId);
//        Assert.notNull(roleEntity, "角色id不存在");
//
//        //获取该角色的所有菜单列表
//        List<SysRoleMenu> roleMenuList = roleMenuService.getListByRoleId(roleId, roleEntity.getCode());
//        if (CollectionUtils.isEmpty(roleMenuList)) {
//            return Lists.newArrayList();
//        }
//        //该角色所有菜单id列表
//        List<String> menuIdList = roleMenuList.stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList());
//        //获取菜单列表数据
//        List<SysMenuVO> menuByMenuIdList = getListByMenuIds(menuIdList);
//        List<SysMenuVO> menuVoByMenuIdList = menuByMenuIdList.stream().sorted(Comparator.comparing(SysMenuVO::getOrderIndex)).collect(Collectors.toList());
//        return TreeUtils.generateTrees(menuVoByMenuIdList);
//    }
//
//    @Transactional(readOnly = true)
//    @Override
//    public List<SysMenuVO> getListByMenuIds(List<String> menuIdList) {
//        List<SysMenu> menuList = sysMenuMapper.selectList(new LambdaQueryWrapper<SysMenu>().in(SysMenu::getId, menuIdList));
//        return transferVo(menuList);
//    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void distributeMenu(SysMenuDistributeDTO dto) {
//        //验证角色id是否存在
//        Assert.notNull(roleMapper.selectById(dto.getRoleId()), "角色id不存在");
//
//        //获取所有的菜单列表
//        List<SysMenu> allMenuList = sysMenuMapper.selectList(null);
//        Assert.notEmpty(allMenuList, "菜单列表数据为空，请联系管理员！！！");
//        List<String> allMenuIdList = allMenuList.stream().map(AbstractBaseModel::getId).collect(Collectors.toList());
//
//        //验证菜单id是否存在
//        Assert.isTrue(allMenuIdList.containsAll(dto.getMenuIds()), "菜单id不存在");
//
//        //获取该角色已经拥有的所有菜单列表
//        List<SysRoleMenu> menuByRoleIdList = roleMenuService.getListByRoleId(dto.getRoleId());
//        //方式二：
//        // 要删除掉该角色已经拥有的菜单，然后重新添加
////        if (CollectionUtils.isNotEmpty(menuByRoleIdList)) {
////            roleMenuMapper.deleteBatchIds(menuByRoleIdList.stream().map(e -> e.getId()).collect(Collectors.toList()));
////        }
////        //添加资源
////        dto.getMenuIds().forEach(e -> {
////            RoleMenu entity = new RoleMenu();
////            entity.setRoleId(dto.getRoleId());
////            entity.setMenuId(e);
////            roleMenuMapper.insert(entity);
////        });
////        //给角色分配菜单权限后，需要重新加载资源数据
////        dynamicSecurityMetadataSource.clearDataSource();
//
//        //过滤出 要新增的菜单列表
//        List<String> addMenuIdList = dto.getMenuIds();
//        if (CollectionUtils.isNotEmpty(menuByRoleIdList)) {
//            //该角色已拥有的菜单id
//            List<String> menuIdList = menuByRoleIdList.stream().map(e -> e.getMenuId()).collect(Collectors.toList());
//            //过滤掉该角色已经拥有的菜单集合
//            addMenuIdList = dto.getMenuIds().stream().filter(e -> !menuIdList.contains(e)).collect(Collectors.toList());
//        }
//        List<SysRoleMenu> roleMenuList = addMenuIdList.stream().map(e -> new SysRoleMenu(dto.getRoleId(), e)).collect(Collectors.toList());
//        roleMenuMapper.insertBatch(roleMenuList);
//        //给角色分配菜单权限后，需要重新加载资源数据
////        dynamicSecurityMetadataSource.clearDataSource();
//    }
//
//    @Override
//    public List<RouterVO> buildMenus(List<SysMenuVO> menus) {
//
//        List<RouterVO> routers = new LinkedList<>();
//        for (SysMenuVO menu : menus) {
//            RouterVO router = new RouterVO();
//            router.setHidden(menu.getIsHidden() == 1);
//            router.setName(getRouteName(menu));
//            router.setPath(getRouterPath(menu));
//            router.setComponent(getComponent(menu));
//            router.setQuery("");
//            router.setMeta(new MetaVO(menu.getName(), menu.getIcon(), false, menu.getPath()));
//            List<SysMenuVO> cMenus = (List<SysMenuVO>) menu.getChildren();
//            if (CollUtil.isNotEmpty(cMenus) && cMenus.size() > 0 && ConstantSystem.TYPE_DIR.equals(menu.getType())) {
//                router.setAlwaysShow(true);
//                router.setRedirect("noRedirect");
//                router.setChildren(buildMenus(cMenus));
//            } else if (isMenuFrame(menu)) {
//                router.setMeta(null);
//                List<RouterVO> childrenList = new ArrayList<>();
//                RouterVO children = new RouterVO();
//                children.setPath(menu.getPath());
//                children.setComponent(menu.getPath());
//                children.setName(StringUtils.capitalize(menu.getPath()));
//                children.setMeta(new MetaVO(menu.getName(), menu.getIcon(), false, menu.getPath()));
//                children.setQuery("");
//                childrenList.add(children);
//                router.setChildren(childrenList);
//            } else if (menu.getParentId().isEmpty() && isInnerLink(menu)) {
//                router.setMeta(new MetaVO(menu.getName(), menu.getIcon()));
//                router.setPath("/");
//                List<RouterVO> childrenList = new ArrayList<>();
//                RouterVO children = new RouterVO();
////                String routerPath = innerLinkReplaceEach(menu.getPath());
//                String routerPath = menu.getPath();
//                children.setPath(routerPath);
//                children.setComponent(ConstantSystem.INNER_LINK);
//                children.setName(StringUtils.capitalize(routerPath));
//                children.setMeta(new MetaVO(menu.getName(), menu.getIcon(), menu.getPath()));
//                childrenList.add(children);
//                router.setChildren(childrenList);
//            }
//            routers.add(router);
//        }
//        return routers;
//    }
//
//    /**
//     * 根据用户ID查询菜单
//     *
//     * @param userId 用户名称
//     * @return 菜单列表
//     */
//    @Override
//    public List<SysMenuVO> selectMenuTreeByUserId(String userId) {
//        SysUserVO userVo = userMapper.selectUserAndRoleByUserId(userId);
//        Assert.notNull(userVo, "账号：" + userId + "不存在");
//        List<String> typeCodeList = Arrays.asList(userVo.getRoleType().split(","));
//        List<SysMenuVO> menuVoList;
//        if (typeCodeList.contains(RoleTypeEnum.ADMIN.getKey()) || typeCodeList.contains(RoleTypeEnum.SUPER_ADMIN.getKey())) {
//            menuVoList = sysMenuMapper.selectMenuTreeAll();
//        } else {
//            menuVoList = sysMenuMapper.selectMenuListByUserId(userId);
//        }
//        return TreeUtils.generateTrees(menuVoList);
//    }
//
//
//    /**
//     * 根据父节点的ID获取所有子节点
//     *
//     * @param list     分类表
//     * @param parentId 传入的父节点ID
//     * @return String
//     */
//    public List<SysMenuVO> getChildPerms(List<SysMenuVO> list, String parentId) {
//        List<SysMenuVO> returnList = new ArrayList<>();
//        for (Iterator<SysMenuVO> iterator = list.iterator(); iterator.hasNext(); ) {
//            SysMenuVO t = iterator.next();
//            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
//            if (t.getParentId().equals(parentId)) {
//                recursionFn(list, t);
//                returnList.add(t);
//            }
//        }
//        return returnList;
//    }
//
//    /**
//     * 递归列表
//     *
//     * @param list
//     * @param t
//     */
//    private void recursionFn(List<SysMenuVO> list, SysMenuVO t) {
//        // 得到子节点列表
//        List<SysMenuVO> childList = getChildList(list, t);
//        t.setChildren(childList);
//        for (SysMenuVO tChild : childList) {
//            if (hasChild(list, tChild)) {
//                recursionFn(list, tChild);
//            }
//        }
//    }
//
//    /**
//     * 得到子节点列表
//     */
//    private List<SysMenuVO> getChildList(List<SysMenuVO> list, SysMenuVO t) {
//        List<SysMenuVO> tlist = new ArrayList<>();
//        Iterator<SysMenuVO> it = list.iterator();
//        while (it.hasNext()) {
//            SysMenuVO n = it.next();
//            if (n.getParentId().equals(t.getId())) {
//                tlist.add(n);
//            }
//        }
//        return tlist;
//    }
//
//    /**
//     * 判断是否有子节点
//     */
//    private boolean hasChild(List<SysMenuVO> list, SysMenuVO t) {
//        return getChildList(list, t).size() > 0;
//    }
//
//    /**
//     * 获取路由名称
//     *
//     * @param menu 菜单信息
//     * @return 路由名称
//     */
//    public String getRouteName(SysMenuVO menu) {
//        String routerName = StringUtils.capitalize(menu.getPath());
//        // 非外链并且是一级目录（类型为目录）
//        if (isMenuFrame(menu)) {
//            routerName = StringUtils.EMPTY;
//        }
//        return routerName;
//    }
//
//    /**
//     * 获取路由地址
//     *
//     * @param menu 菜单信息
//     * @return 路由地址
//     */
//    public String getRouterPath(SysMenuVO menu) {
//        String routerPath = menu.getPath();
//        // 内链打开外网方式
//
//        // 非外链并且是一级目录（类型为目录）
//        if (StringUtils.isBlank(menu.getParentId()) && ConstantSystem.TYPE_DIR.equals(menu.getType())) {
//            routerPath = "/" + menu.getPath();
//        }
//        // 非外链并且是一级目录（类型为菜单）
//        else if (isMenuFrame(menu)) {
//            routerPath = "/";
//        }
//        return routerPath;
//    }
//
//    /**
//     * 获取组件信息
//     *
//     * @param menu 菜单信息
//     * @return 组件信息
//     */
//    public String getComponent(SysMenuVO menu) {
//        String component = ConstantSystem.LAYOUT;
//        if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu)) {
//            component = menu.getComponent();
//        } else if (StringUtils.isEmpty(menu.getComponent()) && StringUtils.isNotBlank(menu.getParentId()) && isInnerLink(menu)) {
//            component = ConstantSystem.INNER_LINK;
//        } else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu)) {
//            component = ConstantSystem.PARENT_VIEW;
//        }
//        return component;
//    }
//
//    /**
//     * 是否为菜单内部跳转
//     *
//     * @param menu 菜单信息
//     * @return 结果
//     */
//    public boolean isMenuFrame(SysMenuVO menu) {
//        return StringUtils.isBlank(menu.getParentId()) && ConstantSystem.TYPE_MENU.equals(menu.getType());
////        return false;
//    }
//
//    /**
//     * 是否为内链组件
//     *
//     * @param menu 菜单信息
//     * @return 结果
//     */
//    public boolean isInnerLink(SysMenuVO menu) {
////        return menu.getIsFrame().equals(ConstantSystem.NO_FRAME) && StringUtils.ishttp(menu.getPath());
//        return false;
//    }
//
//    /**
//     * 是否为parent_view组件
//     *
//     * @param menu 菜单信息
//     * @return 结果
//     */
//    public boolean isParentView(SysMenuVO menu) {
//        return StringUtils.isNotBlank(menu.getParentId()) && ConstantSystem.TYPE_DIR.equals(menu.getType());
//    }
//
//
//    private Map<String, String> getMenuNameMap() {
//        List<SysMenu> allMenuList = sysMenuMapper.selectList(null);
//        Assert.notEmpty(allMenuList, "菜单数据为空，请联系管理员！！！");
//        Map<String, String> menuMapByIdMap = allMenuList.stream().collect(Collectors.toMap(SysMenu::getId, SysMenu::getName));
//        return menuMapByIdMap;
//    }
//
//    private SysMenu validateExists(String name, Integer level) {
//        QueryWrapper<SysMenu> queryWrapper = new QueryWrapper();
//        queryWrapper.lambda().eq(StringUtils.isNotBlank(name), SysMenu::getName, name)
//                .eq(Objects.nonNull(level), SysMenu::getLevel, level);
//        return sysMenuMapper.selectOne(queryWrapper);
//    }
//
//    private QueryWrapper<SysMenu> buildQuery(SysMenuQueryDTO queryDto) {
//        QueryWrapper<SysMenu> queryWrapper = new QueryWrapper<>();
//        if (Objects.nonNull(queryDto)) {
//            queryWrapper.lambda()
//                    .eq(StringUtils.isNotBlank(queryDto.getId()), SysMenu::getId, queryDto.getId())
//                    .like(StringUtils.isNotBlank(queryDto.getName()), SysMenu::getName, queryDto.getName())
//                    .eq(Objects.nonNull(queryDto.getStatus()), SysMenu::getStatus, queryDto.getStatus())
//                    .ge(StringUtils.isNotBlank(queryDto.getStartCreateTime()), SysMenu::getCreateTime, queryDto.getStartCreateTime())
//                    .le(StringUtils.isNotBlank(queryDto.getEndCreateTime()), SysMenu::getCreateTime, queryDto.getEndCreateTime());
//        }
//        return queryWrapper;
//    }
//
//    private SysMenu transferEntity(SysMenu entity, SysMenuDTO dto) {
//        if (Objects.isNull(entity)) {
//            entity = new SysMenu();
//        }
//        BeanUtils.copyProperties(dto, entity);
//        return entity;
//    }
//
//    private List<SysMenuVO> transferVo(List<SysMenu> entities) {
//        if (CollectionUtils.isEmpty(entities)) {
//            return Lists.newArrayList();
//        }
//
//        List<SysMenuVO> voList = entities.stream().map(entity -> {
//            SysMenuVO vo = new SysMenuVO();
//            BeanUtils.copyProperties(entity, vo);
//            return vo;
//        }).collect(Collectors.toList());
//        return voList;
//    }
//
//    private SysMenuVO transferVo(SysMenu entity) {
//        if (Objects.isNull(entity)) {
//            return null;
//        }
//        SysMenuVO vo = new SysMenuVO();
//        BeanUtils.copyProperties(entity, vo);
//        return vo;
//    }
//
//    private SysMenuVO transferVo(SysMenu entity, Map<String, String> menuMapById) {
//        if (Objects.isNull(entity)) {
//            return null;
//        }
//        SysMenuVO vo = new SysMenuVO();
//        BeanUtils.copyProperties(entity, vo);
//        //设置菜单级数Name
////        if (Objects.nonNull(entity.getLevel())) {
////            vo.setLevelName(ConstantSystem.MENU_LEVE_LIST.get(entity.getLevel()));
////        }
//        //设置父级Name
////        if (StringUtils.isNotBlank(entity.getParentId())) {
////            if (Objects.nonNull(menuMapById)) {
////                vo.setParentName(menuMapById.get(entity.getParentId()));
////            }
////        }
//        return vo;
//    }
//}
